/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package juegocartas.clases;

import java.util.ArrayList;
import java.util.List;
import juegocartas.comparadores.AlgoritmoComparacion;
import juegocartas.comparadores.ComparadorChicas;
import juegocartas.comparadores.ComparadorGrandes;
import juegocartas.comparadores.ComparadorJuego;
import juegocartas.comparadores.ComparadorPares;

/**
 *
 * @author JuanFran Jara Bellid
 */
public class JuegoMus {

    public static final int NUMERO_CARTAS_JUGADOR = 4;

    private int turnoJugador;

    public JuegoMus() {
        turnoJugador = 1;
    }

    

    public void barajar(GrupoCartas mazo) {
        mazo.barajar();
    }

    public void repartirCartas(GrupoCartas mazo, List<JugadorIAJuanfran> listadoJugadores) {
        for (int i = 0; i < NUMERO_CARTAS_JUGADOR; i++ ) {
            for (JugadorIAJuanfran jugador : listadoJugadores) {
               jugador.recogeCarta(mazo.cogerCartaSuperior());
            }
        }
        //mostrar la mano del jugador 1
        
    }

    public void siguienteTurno() {
        turnoJugador++;
    }

    public int getTurnoJugador() {
        return turnoJugador;
    }

    public boolean jugarRonda(List<Jugador> jugadores) {
        jugarGrandes(jugadores);
        jugarChicas(jugadores);
        System.out.println("\nPARES");
        System.out.println("=====");
        jugarPares(jugadores);
        System.out.println("\nJUEGO");
        System.out.println("=====");
        jugarJuego(jugadores);
        return true;
    }

    public void jugar(List<Jugador> jugadores) {
        boolean finJuego = false;
        while (!finJuego) {
            finJuego = jugarRonda(jugadores);
        }
    }

    private void jugarGrandes(List<Jugador> jugadores) {
        int turnoActual = turnoJugador;
        System.out.println("GRANDES");
        System.out.println("=======");
        AlgoritmoComparacion juegoGrandes = new AlgoritmoComparacion(new ComparadorGrandes());
        juegoGrandes.resolverGanador(jugadores, "GRANDES");
        
    }

    private void jugarChicas(List<Jugador> jugadores) {
        System.out.println("CHICAS");
        System.out.println("=======");
        AlgoritmoComparacion juegoChicas = new AlgoritmoComparacion(new ComparadorChicas());
        juegoChicas.resolverGanador(jugadores, "CHICAS");
    }

    private void jugarPares(List<Jugador> jugadores) {
        boolean hayPares = false;
        for (Jugador jugador : jugadores) {            
            hayPares |= tenerPares(jugador);
        }

        if (!hayPares) {
            System.out.println("NO HAY PARES.");
            return;
        } else {
            //ver el ganador
            AlgoritmoComparacion juegoPares = new AlgoritmoComparacion(new ComparadorPares());
            juegoPares.resolverGanador(jugadores, "PARES");
        }

    }
    
    public static boolean tenerJuego(GrupoCartas grupoCartas) {
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        int suma = 0;
        for (Carta carta : cartas) {
            suma += getValorCartaJuego(carta);
        }
        if (suma > 30) {
            System.out.println("TIENE juego : " + suma + " puntos.");
            return true;
        }
        System.out.println("NO TIENE juego : " + suma + " puntos.");
        return false;
    }

    public static int obtenerPuntosJuego(GrupoCartas grupoCartas) {
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        int suma = 0;
        for (Carta carta : cartas) {
            suma += getValorCartaJuego(carta);
        }      
        return suma;
    }

    private void jugarJuego(List<Jugador> jugadores) {
        boolean hayJuego = false;
        for (Jugador jugador : jugadores) {
            GrupoCartas cartas = jugador.getMano();
            System.out.print("El jugador " + jugador.getNumeroJugador() + " ");
            hayJuego |= tenerJuego(cartas);
        }

        if (!hayJuego) {
            System.out.println("NO HAY JUEGO. SE JUEGA AL PUNTO.");
             //AlgoritmoComparacion juego = new AlgoritmoComparacion(new ComparadorPunto());
            //juego.resolverGanador(jugadores, "PUNTO");
        } else {
            AlgoritmoComparacion juego = new AlgoritmoComparacion(new ComparadorJuego());
            juego.resolverGanador(jugadores, "JUEGO");
        }

    }

    private void jugarPunto() {
        
    }

    private void realizarDecisionJuego() {
       
    }

    public static boolean tenerPares(Jugador jugador) {
        GrupoCartas grupoCartas = jugador.getMano();
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        for (int i = 0; i < cartas.size(); i++) {
            Carta carta = cartas.get(i);
            int valor = getValorCarta(carta);
            for (int j = i + 1; j < cartas.size(); j++) {
                Carta cartaSiguiente = cartas.get(j);
                if (valor == getValorCarta(cartaSiguiente)) {
                    System.out.print("El jugador " + jugador.getNumeroJugador() + " TIENE pares.");
                    devolverPares(grupoCartas);
                    List<Carta> media = devolverMedia(grupoCartas);
                    if (media != null) {
                        System.out.print(" Exactamente una media de : " + media.get(0).getNumero());
                    }
                    System.out.println("");

                    return true;
                }
            }
        }

        System.out.println("El jugador " + jugador.getNumeroJugador() + " NO tiene pares.");
        return false;
    }

        public static boolean tenerParesSinLog(Jugador jugador) {
        GrupoCartas grupoCartas = jugador.getMano();
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        for (int i = 0; i < cartas.size(); i++) {
            Carta carta = cartas.get(i);
            int valor = getValorCarta(carta);
            for (int j = i + 1; j < cartas.size(); j++) {
                Carta cartaSiguiente = cartas.get(j);
                if (valor == getValorCarta(cartaSiguiente)) {
                    System.out.print("El jugador " + jugador.getNumeroJugador() + " TIENE pares.");
                    devolverPares(grupoCartas);
                   /* int valorMedia = devolverMedia(grupoCartas);
                    if (valorMedia > 0) {
                        System.out.print(" Exactamente una media de : " + valorMedia);
                    }*/
                    System.out.println("");

                    return true;
                }
            }
        }

        System.out.println("El jugador " + jugador.getNumeroJugador() + " NO tiene pares.");
        return false;
    }

    public static int getValorCarta(Carta carta) {
         int valor = carta.getNumero();
        switch (valor) {
            case 2:
                valor = 1;
                break;
            case 3:
                valor = 12;
                break;
        }

        return valor;
    }

    public static int getValorCartaJuego(Carta carta) {
        int valor = carta.getNumero();
        switch (valor) {
            case 2:
                valor = 1;
                break;
            case 3:
                valor = 10;
                break;
            case 11:
                valor = 10;
                break;
            case 12:
                valor = 10;
                break;
        }
        return valor;
    }

   // devuelve el valor de la media que tiene. Si no tiene media, devuelve 0
 /*   public static int devolverMedia(GrupoCartas grupoCartas) {
        List<Carta> cartas = grupoCartas.getGrupoCartas();

        for (int i = 0; i < cartas.size(); i++) {
            int cartasRepetidas = 0;
            Carta carta = cartas.get(i);
            int valor = getValorCarta(carta);
            for (int j = 0; j < cartas.size(); j++) {
                Carta cartaSiguiente = cartas.get(j);
                if (valor == getValorCarta(cartaSiguiente)) {
                    cartasRepetidas++;
                }
            }
            if (cartasRepetidas == 3) {
                return valor;
            }
        }
        return 0;
    }*/

    //devuelve el valor de la media que tiene. Si no tiene media, devuelve 0
    public static List<Carta> devolverMedia(GrupoCartas grupoCartas) {
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        List<Carta> media = new ArrayList<Carta>();
        boolean primeraInsertada = true;
        for (int i = 0; i < cartas.size(); i++) {
            int cartasRepetidas = 0;
            Carta carta = cartas.get(i);
            int valor = getValorCarta(carta);
            for (int j = i + 1; j < cartas.size(); j++) {
                Carta cartaSiguiente = cartas.get(j);
                if (valor == getValorCarta(cartaSiguiente)) {
                    if (primeraInsertada) {
                        primeraInsertada = false;
                        cartasRepetidas = 2;
                        media.add(carta);
                        media.add(cartaSiguiente);
                    } else {
                        cartasRepetidas++;
                        media.add(cartaSiguiente);
                    }

                }
            }
            if (cartasRepetidas == 3) {
                return media;
            }
        }
        return null;
    }
 

    //devuelve un hashmap con dos map, cada uno dice el par que tiene del duples.
    // null si no tiene duples
    public static List<Carta> devolverPares(GrupoCartas grupoCartas) {
        
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        List<Carta> copiaCartas = copiarListadoCartas(cartas);
        List<Carta> contenedor = new ArrayList<Carta>();
        int i = 0;
        while (i < copiaCartas.size()) {
            boolean hayUnPar = false;
            Carta carta = copiaCartas.get(i);
            int valor = getValorCarta(carta);
            for (int j = i + 1; j < copiaCartas.size(); j++) {
                Carta cartaSiguiente  = copiaCartas.get(j);
                if (valor ==  getValorCarta(cartaSiguiente)) {
                    contenedor.add(carta);
                    contenedor.add(cartaSiguiente);
                    copiaCartas.remove(carta);
                    copiaCartas.remove(cartaSiguiente);
                    i = 0;
                    hayUnPar = true;
                    break;
                }
            }
            if (!hayUnPar) {
                i++;
            }
        }
        if (contenedor.size() == 4) {
            //hay duples
            System.out.print("El jugador Tiene Duples!!!");
        } else if (contenedor.size() > 0) {
            List<Carta> media = devolverMedia(grupoCartas);
            if (media != null) {
                return media;
            }
            System.out.println("El jugador tiene pareja de " + contenedor.get(0).getNumero());
        }
        return contenedor;

    }

    public static List<Carta> copiarListadoCartas(List<Carta> cartas) {
        List<Carta> copia = new ArrayList<Carta>();
        for (Carta carta : cartas) {
            copia.add((Carta)carta.clone());
        }
        return copia;
    }

      public static void ordenarCartasGrande(Jugador jugador) {
        GrupoCartas grupoCartas = jugador.getMano();
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        List<Carta> cartasOrdenadas = new ArrayList<Carta>();
        for (Carta carta : cartas) {
            boolean introducida = false;
            for (int i = 0; i < cartasOrdenadas.size() && !introducida; i++) {
                Carta cartaOrdenada = cartasOrdenadas.get(i);
                if (JuegoMus.getValorCarta(carta) >= JuegoMus.getValorCarta(cartaOrdenada)) {
                    cartasOrdenadas.add(i, carta);
                    introducida = true;
                }
            }
            if (!introducida) {
                cartasOrdenadas.add(carta);
            }
        }
        grupoCartas.setGrupoCartas(cartasOrdenadas);
        jugador.setMano(grupoCartas);
    }

       public static List<Carta> ordenarCartasPares(List<Carta> cartas) {

        List<Carta> cartasOrdenadas = new ArrayList<Carta>();
        for (Carta carta : cartas) {
            boolean introducida = false;
            for (int i = 0; i < cartasOrdenadas.size() && !introducida; i++) {
                Carta cartaOrdenada = cartasOrdenadas.get(i);
                if (JuegoMus.getValorCarta(carta) >= JuegoMus.getValorCarta(cartaOrdenada)) {
                    cartasOrdenadas.add(i, carta);
                    introducida = true;
                }
            }
            if (!introducida) {
                cartasOrdenadas.add(carta);
            }
        }
        return cartasOrdenadas;
    }


       public static void ordenarCartasChica(Jugador jugador) {
        GrupoCartas grupoCartas = jugador.getMano();
        List<Carta> cartas = grupoCartas.getGrupoCartas();
        List<Carta> cartasOrdenadas = new ArrayList<Carta>();
        for (Carta carta : cartas) {
            boolean introducida = false;
            for (int i = 0; i < cartasOrdenadas.size() && !introducida; i++) {
                Carta cartaOrdenada = cartasOrdenadas.get(i);
                if (JuegoMus.getValorCarta(carta) <= JuegoMus.getValorCarta(cartaOrdenada)) {
                    cartasOrdenadas.add(i, carta);
                    introducida = true;
                }
            }
            if (!introducida) {
                cartasOrdenadas.add(carta);
            }
        }
        grupoCartas.setGrupoCartas(cartasOrdenadas);
        jugador.setMano(grupoCartas);
    }

}
